D:\a\tools.proto\tools.proto\compiler\src\compiler\protocol.rs

Source
// Copyright (c) 2024, BlockProject 3D
//
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//     * Redistributions of source code must retain the above copyright notice,
//       this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above copyright notice,
//       this list of conditions and the following disclaimer in the documentation
//       and/or other materials provided with the distribution.
//     * Neither the name of BlockProject 3D nor the names of its contributors
//       may be used to endorse or promote products derived from this software
//       without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

use crate::compiler::error::Error;
use crate::compiler::imports::Import;
use crate::compiler::message::{FieldType, Message};
use crate::compiler::r#enum::Enum;
use crate::compiler::structure::Structure;
use crate::compiler::union::Union;
use crate::compiler::util::imports::ImportSolver;
use crate::compiler::util::objects::{name_index, ObjectStore};
use crate::compiler::util::types::{Name, TypePathMap};
use crate::model::message::MessageFieldValue;
use crate::model::protocol::{Description, Endianness};
use crate::model::typedef::Typedef;
use bp3d_debug::{info, trace};
use std::borrow::Cow;
use std::collections::BTreeMap;
use std::rc::Rc;
use crate::compiler::util::protocols::ProtocolStore;

name_index!(Typedef => name);

#[derive(Clone, Debug)]
pub struct Protocol {
    pub full_name: String,
    pub description: Option<Description>,
    pub endianness: Endianness,
    pub type_path_map: TypePathMap,
    pub structs: ObjectStore<Structure>,
    pub messages: ObjectStore<Message>,
    pub enums: ObjectStore<Enum>,
    pub unions: ObjectStore<Union>,
    pub types: ObjectStore<Typedef>,
}

impl bp3d_util::index_map::Index for Protocol {
    type Key = str;

    fn index(&self) -> &Self::Key {
        &self.full_name
    }
}

impl Protocol {
    pub fn name(&self) -> &str {
        if let Some(id1) = self.full_name.rfind("::") {
            &self.full_name[id + 2..]
        } else {
            &self.full_name
        }
    }

    pub fn package(&self) -> &str {
        if let Some(id1) = self.full_name.rfind("::") {
            &self.full_name[..id]
        } else {
            ""
        }
    }

    pub fn iter_codecs(&self) -> impl Iterator<Item = &str> {
        self.messages.iter().flat_map(|v| v.fields.iter().filter_map(66|v| v.codec.as_deref())66)
    }

    pub fn from_model<T: ImportSolver, U>(
        mut value: crate::model::Protocol,
        protocols: &ProtocolStore<T, U>,
        package: &str,
    ) -> Result<Self, Error> {
        let full_name = if package.is_empty() {
            value.name
        } else {
            format!("{}::{}", package, value.name)
        };
        trace!("Compiling protocol {}", full_name);
        let mut proto = Protocol {
            full_name,
            description: value.description,
            endianness: value.endianness.unwrap_or(Endianness::Little),
            type_path_map: TypePathMap::new(),
            structs: ObjectStore::new(),
            messages: ObjectStore::new(),
            enums: ObjectStore::new(),
            unions: ObjectStore::new(),
            types: ObjectStore::new(),
        };
        info!("Running import solver pass...");
        if let Some(mut imports11) = value.imports {
            let mut solved_imports = Vec::new();
            while let Some(v39) = imports.pop() {
                let protocol_path = if package.is_empty() || v.protocol.contains("::")1 {
                    Cow::Borrowed(&v.protocol)
                } else {
                    Cow::Owned(format!("{}::{}", package, v.protocol))
                };
                trace!({protocol=&**protocol_path} {type=&*v.type_name}, "Solving import");
                let r = protocols.get(&protocol_path);
                let r = match r {
                    Some(r) => r,
                    None => return Err(Error::UndefinedReference(v.protocol)),
                };
                let ty = r
                    .structs
                    .get(&v.type_name)
                    .map(Import::Struct)
                    .or_else(|| r.messages.get(&v.type_name).map(Import::Message)13)
                    .or_else(|| r.unions.get(&v.type_name).map(Import::Union)6)
                    .or_else(|| r.enums.get(&v.type_name).map(Import::Enum)4)
                    .or_else(|| r.types.get(&v.type_name).map(Import::Type)2)
                    .ok_or(Error::UnresolvedImport(format!("{}::{}", protocol_path, v.type_name)))?0;
                let type_path = protocols.get_full_type_path(r, &v.type_name).ok_or(Error::SolverError)?0;
                solved_imports.push(ty);
                let count1 = imports.iter().filter(|vv| vv.type_name == v.type_name).count();
                let count2 = solved_imports.iter().filter(|vv| vv.name() == v.type_name).count()39;
                let is_ambiguous = count1 > 0 || count2 > 137;
                proto.type_path_map.add(&ty, type_path);
                if is_ambiguous {
                    trace!({protocol=&**protocol_path} {type=&*v.type_name}, "Import is ambiguous, import it as {}::{}", v.protocol, v.type_name);
                    ty.insert(format!("{}::{}", v.protocol, v.type_name), &mut proto);
                } else {
                    trace!({protocol=&**protocol_path} {type=&*v.type_name}, "Import is not ambiguous");
                    ty.insert(v.type_name, &mut proto);
                }
            }
        }
        info!("Adding typedefs...");
        if let Some(types4) = value.types {
            for v12 in types {
                trace!({model=?&v}, "Adding typedef to protocol");
                proto.types.insert(Rc::new(v));
            }
        }
        info!("Running type inference pass...");
        if let Some(structs47) = &mut value.structs {
            for v76 in structs {
                for field133 in &mut v.fields {
                    if let Some(info) =
                        field.item_type.as_ref().and_then(|v| proto.types.get(v)13).and_then(|v| v.to_struct()0)
                    {
                        trace!({typedef=?info}, "Inferred {} as {}", field.name, info.name);
                        let name = std::mem::replace(field, info.clone()).name;
                        field.name = name;
                    }
                }
            }
        }
        if let Some(messages28) = &mut value.messages {
            for v44 in messages {
                for field78 in &mut v.fields {
                    if let Some(info) =
                        field.item_type.as_ref().and_then(|v| proto.types.get(v)32).and_then(|v| v.to_message()12)
                    {
                        trace!({typedef=?info}, "Inferred {} as {}", field.name, info.name);
                        let name = std::mem::replace(field, info.clone()).name;
                        field.name = name;
                    }
                }
            }
        }
        info!("Running compiler pass...");
        if let Some(enums7) = value.enums {
            trace!(">> Compiling enums...");
            for v7 in enums {
                trace!({model=?&v}, "Compiling enum");
                let v6 = Rc::new(Enum::from_model(v)?1);
                proto.enums.insert(v);
            }
        }
        if let Some(structs47) = value.structs {
            trace!(">> Compiling structures...");
            for v76 in structs {
                trace!({model=?&v}, "Compiling structure");
                let v67 = Rc::new(Structure::from_model(&proto, v)?9);
                proto.structs.insert(v);
            }
        }
        let mut union_messages = BTreeMap::new();
        if let Some(mut messages28) = value.messages {
            trace!(">> Extracting unions and messages with references to unions...");
            let len = messages.len();
            for i in 1..len + 128 {
                let i = len - i;
                let has_unions = messages[i].fields.iter().any(|v| match &v.value {
                    None => false,
                    Some(v) => matches!49(v, MessageFieldValue::Union { .. }),
                });
                if has_unions {
                    let msg = messages.remove(i);
                    union_messages.insert(i, msg);
                }
            }
            let pos = len;
            let len = messages.len();
            for i in 1..len + 128 {
                let i = len - i;
                let has_ref = union_messages.values().any(|union| messages[i].references(&union.name)6);
                if has_ref {
                    let msg = messages.remove(i);
                    union_messages.insert(pos + i, msg);
                }
            }
            trace!(">> Compiling messages with no references to unions...");
            for v33 in messages {
                trace!({model=?&v}, "Compiling message");
                let v28 = Rc::new(Message::from_model(&proto, v)?5);
                proto.messages.insert(v);
            }
        }
        if let Some(unions10) = value.unions {
            trace!(">> Compiling unions...");
            for v10 in unions {
                trace!({model=?&v}, "Compiling union");
                let v = Rc::new(Union::from_model(&proto, v)?0);
                proto.unions.insert(v);
            }
        }
        trace!(">> Compiling messages with references to unions...");
        for (_, msg11) in union_messages {
            trace!({model=?&msg}, "Compiling message");
            let v6 = Rc::new(Message::from_model(&proto, msg)?5);
            proto.messages.insert(v);
        }

        info!("Running list sanitizer pass...");
        for msg33 in proto.messages.iter() {
            if msg.is_embedded() {
                for field in &msg.fields8 {
                    let flag = match &field.ty {
                        FieldType::Container(v) => v.nested,
                        _ => true,
                    };
                    if !flag {
                        return Err(Error::MissingNestedList(format!("{}::{}", msg.name, field.name)));
                    }
                }
            }
        }
        Ok(proto)
    }
}

Coverage Report

Created: 2024-12-26 12:25

Line	Count	Source
1		// Copyright (c) 2024, BlockProject 3D
2		//
3		// All rights reserved.
4		//
5		// Redistribution and use in source and binary forms, with or without modification,
6		// are permitted provided that the following conditions are met:
7		//
8		// * Redistributions of source code must retain the above copyright notice,
9		// this list of conditions and the following disclaimer.
10		// * Redistributions in binary form must reproduce the above copyright notice,
11		// this list of conditions and the following disclaimer in the documentation
12		// and/or other materials provided with the distribution.
13		// * Neither the name of BlockProject 3D nor the names of its contributors
14		// may be used to endorse or promote products derived from this software
15		// without specific prior written permission.
16		//
17		// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18		// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19		// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20		// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
21		// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
22		// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
23		// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
24		// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
25		// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
26		// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
27		// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28
29		use crate::compiler::error::Error;
30		use crate::compiler::imports::Import;
31		use crate::compiler::message::{FieldType, Message};
32		use crate::compiler::r#enum::Enum;
33		use crate::compiler::structure::Structure;
34		use crate::compiler::union::Union;
35		use crate::compiler::util::imports::ImportSolver;
36		use crate::compiler::util::objects::{name_index, ObjectStore};
37		use crate::compiler::util::types::{Name, TypePathMap};
38		use crate::model::message::MessageFieldValue;
39		use crate::model::protocol::{Description, Endianness};
40		use crate::model::typedef::Typedef;
41		use bp3d_debug::{info, trace};
42		use std::borrow::Cow;
43		use std::collections::BTreeMap;
44		use std::rc::Rc;
45		use crate::compiler::util::protocols::ProtocolStore;
46
47		name_index!(Typedef => name);
48
49		#[derive(Clone, Debug)]
50		pub struct Protocol {
51		pub full_name: String,
52		pub description: Option<Description>,
53		pub endianness: Endianness,
54		pub type_path_map: TypePathMap,
55		pub structs: ObjectStore<Structure>,
56		pub messages: ObjectStore<Message>,
57		pub enums: ObjectStore<Enum>,
58		pub unions: ObjectStore<Union>,
59		pub types: ObjectStore<Typedef>,
60		}
61
62		impl bp3d_util::index_map::Index for Protocol {
63		type Key = str;
64
65	178	fn index(&self) -> &Self::Key {
66	178	&self.full_name
67	178	}
68		}
69
70		impl Protocol {
71	37	pub fn name(&self) -> &str {
72	37	if let Some( id1 ) = self.full_name.rfind("::") { Branch (72:16): [True: 1, False: 36] Branch (72:16): [Folded - Ignored]
73	1	&self.full_name[id + 2..]
74		} else {
75	36	&self.full_name
76		}
77	37	}
78
79	39	pub fn package(&self) -> &str {
80	39	if let Some( id1 ) = self.full_name.rfind("::") { Branch (80:16): [True: 1, False: 38] Branch (80:16): [Folded - Ignored]
81	1	&self.full_name[..id]
82		} else {
83	38	""
84		}
85	39	}
86
87	76	pub fn iter_codecs(&self) -> impl Iterator<Item = &str> {
88	126	self.messages.iter().flat_map(\|v\| v.fields.iter().filter_map(66 \|v\| v.codec.as_deref() )66 )
89	76	}
90
91	58	pub fn from_model<T: ImportSolver, U>(
92	58	mut value: crate::model::Protocol,
93	58	protocols: &ProtocolStore<T, U>,
94	58	package: &str,
95	58	) -> Result<Self, Error> {
96	58	let full_name = if package.is_empty() { Branch (96:28): [True: 18, False: 2] Branch (96:28): [Folded - Ignored] Branch (96:28): [True: 18, False: 0] Branch (96:28): [Folded - Ignored] Branch (96:28): [True: 5, False: 0] Branch (96:28): [True: 1, False: 0] Branch (96:28): [True: 1, False: 0] Branch (96:28): [True: 4, False: 0] Branch (96:28): [True: 3, False: 0] Branch (96:28): [True: 5, False: 0] Branch (96:28): [True: 1, False: 0]
97	56	value.name
98		} else {
99	2	format!("{}::{}", package, value.name)
100		};
101	58	trace!("Compiling protocol {}", full_name);
102	58	let mut proto = Protocol {
103	58	full_name,
104	58	description: value.description,
105	58	endianness: value.endianness.unwrap_or(Endianness::Little),
106	58	type_path_map: TypePathMap::new(),
107	58	structs: ObjectStore::new(),
108	58	messages: ObjectStore::new(),
109	58	enums: ObjectStore::new(),
110	58	unions: ObjectStore::new(),
111	58	types: ObjectStore::new(),
112	58	};
113	58	info!("Running import solver pass...");
114	58	if let Some( mut imports11 ) = value.imports { Branch (114:16): [True: 6, False: 14] Branch (114:16): [Folded - Ignored] Branch (114:16): [True: 5, False: 13] Branch (114:16): [Folded - Ignored] Branch (114:16): [True: 0, False: 5] Branch (114:16): [True: 0, False: 1] Branch (114:16): [True: 0, False: 1] Branch (114:16): [True: 0, False: 4] Branch (114:16): [True: 0, False: 3] Branch (114:16): [True: 0, False: 5] Branch (114:16): [True: 0, False: 1]
115	11	let mut solved_imports = Vec::new();
116	50	while let Some( v39 ) = imports.pop() { Branch (116:23): [True: 20, False: 6] Branch (116:23): [Folded - Ignored] Branch (116:23): [True: 19, False: 5] Branch (116:23): [Folded - Ignored] Branch (116:23): [True: 0, False: 0] Branch (116:23): [True: 0, False: 0] Branch (116:23): [True: 0, False: 0] Branch (116:23): [True: 0, False: 0] Branch (116:23): [True: 0, False: 0] Branch (116:23): [True: 0, False: 0] Branch (116:23): [True: 0, False: 0]
117	39	let protocol_path = if package.is_empty() \|\| v.protocol.contains("::")1 { Branch (117:40): [True: 19, False: 1] Branch (117:62): [True: 1, False: 0] Branch (117:40): [Folded - Ignored] Branch (117:62): [Folded - Ignored] Branch (117:40): [True: 19, False: 0] Branch (117:62): [True: 0, False: 0] Branch (117:40): [Folded - Ignored] Branch (117:62): [Folded - Ignored] Branch (117:40): [True: 0, False: 0] Branch (117:62): [True: 0, False: 0] Branch (117:40): [True: 0, False: 0] Branch (117:62): [True: 0, False: 0] Branch (117:40): [True: 0, False: 0] Branch (117:62): [True: 0, False: 0] Branch (117:40): [True: 0, False: 0] Branch (117:62): [True: 0, False: 0] Branch (117:40): [True: 0, False: 0] Branch (117:62): [True: 0, False: 0] Branch (117:40): [True: 0, False: 0] Branch (117:62): [True: 0, False: 0] Branch (117:40): [True: 0, False: 0] Branch (117:62): [True: 0, False: 0]
118	39	Cow::Borrowed(&v.protocol)
119		} else {
120	0	Cow::Owned(format!("{}::{}", package, v.protocol))
121		};
122	39	trace!({protocol=&*protocol_path} {type=&v.type_name}, "Solving import");
123	39	let r = protocols.get(&protocol_path);
124	39	let r = match r {
125	39	Some(r) => r,
126	0	None => return Err(Error::UndefinedReference(v.protocol)),
127		};
128	39	let ty = r
129	39	.structs
130	39	.get(&v.type_name)
131	39	.map(Import::Struct)
132	39	.or_else(\|\| r.messages.get(&v.type_name).map(Import::Message)13 )
133	39	.or_else(\|\| r.unions.get(&v.type_name).map(Import::Union)6 )
134	39	.or_else(\|\| r.enums.get(&v.type_name).map(Import::Enum)4 )
135	39	.or_else(\|\| r.types.get(&v.type_name).map(Import::Type)2 )
136	39	.ok_or(Error::UnresolvedImport(format!("{}::{}", protocol_path, v.type_name))) ?0 ;
137	39	let type_path = protocols.get_full_type_path(r, &v.type_name).ok_or(Error::SolverError) ?0 ;
138	39	solved_imports.push(ty);
139	160	let count1 = imports.iter().filter(\|vv\| vv.type_name == v.type_name).count();
140	199	let count2 = solved_imports.iter().filter(\|vv\| vv.name() == v.type_name ).count()39 ;
141	39	let is_ambiguous = count1 > 0 \|\| count2 > 137 ; Branch (141:36): [True: 1, False: 19] Branch (141:36): [Folded - Ignored] Branch (141:36): [True: 1, False: 18] Branch (141:36): [Folded - Ignored] Branch (141:36): [True: 0, False: 0] Branch (141:36): [True: 0, False: 0] Branch (141:36): [True: 0, False: 0] Branch (141:36): [True: 0, False: 0] Branch (141:36): [True: 0, False: 0] Branch (141:36): [True: 0, False: 0] Branch (141:36): [True: 0, False: 0]
142	39	proto.type_path_map.add(&ty, type_path);
143	39	if is_ambiguous { Branch (143:20): [True: 2, False: 18] Branch (143:20): [Folded - Ignored] Branch (143:20): [True: 2, False: 17] Branch (143:20): [Folded - Ignored] Branch (143:20): [True: 0, False: 0] Branch (143:20): [True: 0, False: 0] Branch (143:20): [True: 0, False: 0] Branch (143:20): [True: 0, False: 0] Branch (143:20): [True: 0, False: 0] Branch (143:20): [True: 0, False: 0] Branch (143:20): [True: 0, False: 0]
144	4	trace!({protocol=&*protocol_path} {type=&v.type_name}, "Import is ambiguous, import it as {}::{}", v.protocol, v.type_name);
145	4	ty.insert(format!("{}::{}", v.protocol, v.type_name), &mut proto);
146	35	} else {
147	35	trace!({protocol=&*protocol_path} {type=&v.type_name}, "Import is not ambiguous");
148	35	ty.insert(v.type_name, &mut proto);
149	35	}
150		}
151	47	}
152	58	info!("Adding typedefs...");
153	58	if let Some( types4 ) = value.types { Branch (153:16): [True: 2, False: 18] Branch (153:16): [Folded - Ignored] Branch (153:16): [True: 2, False: 16] Branch (153:16): [Folded - Ignored] Branch (153:16): [True: 0, False: 5] Branch (153:16): [True: 0, False: 1] Branch (153:16): [True: 0, False: 1] Branch (153:16): [True: 0, False: 4] Branch (153:16): [True: 0, False: 3] Branch (153:16): [True: 0, False: 5] Branch (153:16): [True: 0, False: 1]
154	16	for v12 in types {
155	12	trace!({model=?&v}, "Adding typedef to protocol");
156	12	proto.types.insert(Rc::new(v));
157	12	}
158	54	}
159	58	info!("Running type inference pass...");
160	58	if let Some( structs47 ) = &mut value.structs { Branch (160:16): [True: 17, False: 3] Branch (160:16): [Folded - Ignored] Branch (160:16): [True: 16, False: 2] Branch (160:16): [Folded - Ignored] Branch (160:16): [True: 0, False: 5] Branch (160:16): [True: 1, False: 0] Branch (160:16): [True: 1, False: 0] Branch (160:16): [True: 4, False: 0] Branch (160:16): [True: 3, False: 0] Branch (160:16): [True: 5, False: 0] Branch (160:16): [True: 0, False: 1]
161	123	for v76 in structs {
162	209	for field133 in &mut v.fields {
163	0	if let Some(info) = Branch (163:28): [True: 0, False: 60] Branch (163:28): [Folded - Ignored] Branch (163:28): [True: 0, False: 59] Branch (163:28): [Folded - Ignored] Branch (163:28): [True: 0, False: 0] Branch (163:28): [True: 0, False: 1] Branch (163:28): [True: 0, False: 1] Branch (163:28): [True: 0, False: 4] Branch (163:28): [True: 0, False: 2] Branch (163:28): [True: 0, False: 6] Branch (163:28): [True: 0, False: 0]
164	133	field.item_type.as_ref().and_then(\|v\| proto.types.get(v)13 ).and_then(\|v\| v.to_struct()0 )
165	0	{
166	0	trace!({typedef=?info}, "Inferred {} as {}", field.name, info.name);
167	0	let name = std::mem::replace(field, info.clone()).name;
168	0	field.name = name;
169	133	}
170		}
171		}
172	11	}
173	58	if let Some( messages28 ) = &mut value.messages { Branch (173:16): [True: 10, False: 10] Branch (173:16): [Folded - Ignored] Branch (173:16): [True: 8, False: 10] Branch (173:16): [Folded - Ignored] Branch (173:16): [True: 5, False: 0] Branch (173:16): [True: 0, False: 1] Branch (173:16): [True: 0, False: 1] Branch (173:16): [True: 0, False: 4] Branch (173:16): [True: 0, False: 3] Branch (173:16): [True: 5, False: 0] Branch (173:16): [True: 0, False: 1]
174	72	for v44 in messages {
175	122	for field78 in &mut v.fields {
176	12	if let Some(info) = Branch (176:28): [True: 6, False: 30] Branch (176:28): [Folded - Ignored] Branch (176:28): [True: 6, False: 21] Branch (176:28): [Folded - Ignored] Branch (176:28): [True: 0, False: 6] Branch (176:28): [True: 0, False: 0] Branch (176:28): [True: 0, False: 0] Branch (176:28): [True: 0, False: 0] Branch (176:28): [True: 0, False: 0] Branch (176:28): [True: 0, False: 9] Branch (176:28): [True: 0, False: 0]
177	78	field.item_type.as_ref().and_then(\|v\| proto.types.get(v)32 ).and_then(\|v\| v.to_message()12 )
178	12	{
179	12	trace!({typedef=?info}, "Inferred {} as {}", field.name, info.name);
180	12	let name = std::mem::replace(field, info.clone()).name;
181	12	field.name = name;
182	66	}
183		}
184		}
185	30	}
186	58	info!("Running compiler pass...");
187	58	if let Some( enums7 ) = value.enums { Branch (187:16): [True: 3, False: 17] Branch (187:16): [Folded - Ignored] Branch (187:16): [True: 3, False: 15] Branch (187:16): [Folded - Ignored] Branch (187:16): [True: 0, False: 5] Branch (187:16): [True: 0, False: 1] Branch (187:16): [True: 0, False: 1] Branch (187:16): [True: 0, False: 4] Branch (187:16): [True: 0, False: 3] Branch (187:16): [True: 0, False: 5] Branch (187:16): [True: 1, False: 0]
188	7	trace!(">> Compiling enums...");
189	13	for v7 in enums {
190	7	trace!({model=?&v}, "Compiling enum");
191	7	let v6 = Rc::new(Enum::from_model(v) ?1 );
192	6	proto.enums.insert(v);
193		}
194	51	}
195	57	if let Some( structs47 ) = value.structs { Branch (195:16): [True: 17, False: 3] Branch (195:16): [Folded - Ignored] Branch (195:16): [True: 16, False: 2] Branch (195:16): [Folded - Ignored] Branch (195:16): [True: 0, False: 5] Branch (195:16): [True: 1, False: 0] Branch (195:16): [True: 1, False: 0] Branch (195:16): [True: 4, False: 0] Branch (195:16): [True: 3, False: 0] Branch (195:16): [True: 5, False: 0] Branch (195:16): [True: 0, False: 0]
196	47	trace!(">> Compiling structures...");
197	114	for v76 in structs {
198	76	trace!({model=?&v}, "Compiling structure");
199	76	let v67 = Rc::new(Structure::from_model(&proto, v) ?9 );
200	67	proto.structs.insert(v);
201		}
202	10	}
203	48	let mut union_messages = BTreeMap::new();
204	48	if let Some( mut messages28 ) = value.messages { Branch (204:16): [True: 10, False: 10] Branch (204:16): [Folded - Ignored] Branch (204:16): [True: 8, False: 10] Branch (204:16): [Folded - Ignored] Branch (204:16): [True: 5, False: 0] Branch (204:16): [True: 0, False: 0] Branch (204:16): [True: 0, False: 0] Branch (204:16): [True: 0, False: 0] Branch (204:16): [True: 0, False: 0] Branch (204:16): [True: 5, False: 0] Branch (204:16): [True: 0, False: 0]
205	28	trace!(">> Extracting unions and messages with references to unions...");
206	28	let len = messages.len();
207	44	for i in 1.. len + 128 {
208	44	let i = len - i;
209	78	let has_unions = messages[i].fields.iter().any(\|v\| match &v.value {
210	20	None => false,
211	58	Some(v) => matches!49 (v, MessageFieldValue::Union { .. }),
212	78	});
213	44	if has_unions { Branch (213:20): [True: 2, False: 16] Branch (213:20): [Folded - Ignored] Branch (213:20): [True: 2, False: 13] Branch (213:20): [Folded - Ignored] Branch (213:20): [True: 0, False: 6] Branch (213:20): [True: 0, False: 0] Branch (213:20): [True: 0, False: 0] Branch (213:20): [True: 0, False: 0] Branch (213:20): [True: 0, False: 0] Branch (213:20): [True: 5, False: 0] Branch (213:20): [True: 0, False: 0]
214	9	let msg = messages.remove(i);
215	9	union_messages.insert(i, msg);
216	35	}
217		}
218	28	let pos = len;
219	28	let len = messages.len();
220	35	for i in 1.. len + 128 {
221	35	let i = len - i;
222	35	let has_ref = union_messages.values().any(\|union\| messages[i].references(&union.name)6 );
223	35	if has_ref { Branch (223:20): [True: 1, False: 15] Branch (223:20): [Folded - Ignored] Branch (223:20): [True: 1, False: 12] Branch (223:20): [Folded - Ignored] Branch (223:20): [True: 0, False: 6] Branch (223:20): [True: 0, False: 0] Branch (223:20): [True: 0, False: 0] Branch (223:20): [True: 0, False: 0] Branch (223:20): [True: 0, False: 0] Branch (223:20): [True: 0, False: 0] Branch (223:20): [True: 0, False: 0]
224	2	let msg = messages.remove(i);
225	2	union_messages.insert(pos + i, msg);
226	33	}
227		}
228	28	trace!(">> Compiling messages with no references to unions...");
229	56	for v33 in messages {
230	33	trace!({model=?&v}, "Compiling message");
231	33	let v28 = Rc::new(Message::from_model(&proto, v) ?5 );
232	28	proto.messages.insert(v);
233		}
234	20	}
235	43	if let Some( unions10 ) = value.unions { Branch (235:16): [True: 3, False: 17] Branch (235:16): [Folded - Ignored] Branch (235:16): [True: 3, False: 15] Branch (235:16): [Folded - Ignored] Branch (235:16): [True: 0, False: 0] Branch (235:16): [True: 0, False: 0] Branch (235:16): [True: 0, False: 0] Branch (235:16): [True: 0, False: 0] Branch (235:16): [True: 0, False: 0] Branch (235:16): [True: 4, False: 1] Branch (235:16): [True: 0, False: 0]
236	10	trace!(">> Compiling unions...");
237	20	for v10 in unions {
238	10	trace!({model=?&v}, "Compiling union");
239	10	let v = Rc::new(Union::from_model(&proto, v) ?0 );
240	10	proto.unions.insert(v);
241		}
242	33	}
243	43	trace!(">> Compiling messages with references to unions...");
244	49	for (_, msg11 ) in union_messages {
245	11	trace!({model=?&msg}, "Compiling message");
246	11	let v6 = Rc::new(Message::from_model(&proto, msg) ?5 );
247	6	proto.messages.insert(v);
248		}
249
250	38	info!("Running list sanitizer pass...");
251	38	for msg33 in proto.messages.iter() {
252	33	if msg.is_embedded() { Branch (252:16): [True: 4, False: 14] Branch (252:16): [Folded - Ignored] Branch (252:16): [True: 4, False: 11] Branch (252:16): [Folded - Ignored] Branch (252:16): [True: 0, False: 0] Branch (252:16): [True: 0, False: 0] Branch (252:16): [True: 0, False: 0] Branch (252:16): [True: 0, False: 0] Branch (252:16): [True: 0, False: 0] Branch (252:16): [True: 0, False: 0] Branch (252:16): [True: 0, False: 0]
253	16	for field in & msg.fields8 {
254	16	let flag = match &field.ty {
255	2	FieldType::Container(v) => v.nested,
256	14	_ => true,
257		};
258	16	if !flag { Branch (258:24): [True: 0, False: 8] Branch (258:24): [Folded - Ignored] Branch (258:24): [True: 0, False: 8] Branch (258:24): [Folded - Ignored] Branch (258:24): [True: 0, False: 0] Branch (258:24): [True: 0, False: 0] Branch (258:24): [True: 0, False: 0] Branch (258:24): [True: 0, False: 0] Branch (258:24): [True: 0, False: 0] Branch (258:24): [True: 0, False: 0] Branch (258:24): [True: 0, False: 0]
259	0	return Err(Error::MissingNestedList(format!("{}::{}", msg.name, field.name)));
260	16	}
261		}
262	25	}
263		}
264	38	Ok(proto)
265	58	}
266		}